// package main

// import (

// 	// "grpc-jwt-yonghurenzheng/jwt_grpc_gin/handlers" // 复用之前的JWT中间件

// 	// "github.com/gin-gonic/gin"

// 	"context"
// 	"fmt"
// 	"log"
// 	"net/http"
// 	"strconv"
// 	"strings"

// 	// 确保这里的 import 路径与您项目 go.mod 中定义的模块名一致
// 	"grpc-jwt-yonghurenzheng/jwt_grpc_gin/config"
// 	"grpc-jwt-yonghurenzheng/jwt_grpc_gin/models"
// 	pb "grpc-jwt-yonghurenzheng/jwt_grpc_gin/proto"

// 	"github.com/gin-gonic/gin"
// 	"github.com/golang-jwt/jwt/v4"
// 	"google.golang.org/grpc"
// 	"google.golang.org/grpc/credentials/insecure"
// )

// // 全局 gRPC 客户端变量
// var authClient pb.AuthServiceClient
// var userClient pb.UserServiceClient

// // === HTTP Handlers (负责将 HTTP 请求转换为 gRPC 调用) ===

// // registerHandler 接收 HTTP 注册请求，并调用 Auth Service 的 gRPC 接口
// func registerHandler(c *gin.Context) {
// 	var req pb.RegisterRequest
// 	if err := c.ShouldBindJSON(&req); err != nil {
// 		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据: " + err.Error()})
// 		return
// 	}

// 	// 调用 gRPC 服务
// 	res, err := authClient.Register(context.Background(), &req)
// 	if err != nil {
// 		c.JSON(http.StatusInternalServerError, gin.H{"error": "注册失败: " + err.Error()})
// 		return
// 	}

// 	c.JSON(http.StatusCreated, res)
// }

// // loginHandler 接收 HTTP 登录请求，并调用 Auth Service 的 gRPC 接口
// func loginHandler(c *gin.Context) {
// 	var req pb.LoginRequest
// 	if err := c.ShouldBindJSON(&req); err != nil {
// 		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据: " + err.Error()})
// 		return
// 	}

// 	// 调用 gRPC 服务
// 	res, err := authClient.Login(context.Background(), &req)
// 	if err != nil {
// 		c.JSON(http.StatusUnauthorized, gin.H{"error": "登录失败: " + err.Error()})
// 		return
// 	}

// 	c.JSON(http.StatusOK, res)
// }

// // profileHandler (正确版本)
// func profileHandler(c *gin.Context) {
// 	// ① 从JWT中间件设置的上下文中获取 claims
// 	claimsAny, exists := c.Get("userClaims")
// 	if !exists {
// 		c.JSON(http.StatusUnauthorized, gin.H{"error": "未登录或Token无效"})
// 		return
// 	}
// 	// 进行类型断言，将 interface{} 转换为 *models.Claims
// 	claims, ok := claimsAny.(*models.Claims)
// 	if !ok {
// 		c.JSON(http.StatusInternalServerError, gin.H{"error": "无法解析用户信息"})
// 		return
// 	}

// 	// ② 从URL路径参数中获取目标用户ID
// 	targetUserIDStr := c.Param("id")
// 	targetUserID, err := strconv.ParseInt(targetUserIDStr, 10, 64)
// 	if err != nil {
// 		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
// 		return
// 	}

// 	// ③【核心修正】比较 Token 中的用户ID 和 路径中的目标ID
// 	if claims.UserID != targetUserID {
// 		c.JSON(http.StatusForbidden, gin.H{"error": "权限不足，禁止访问他人信息"})
// 		return
// 	}

// 	// 调用 gRPC 服务 (现在是安全的)
// 	res, err := userClient.GetUserProfile(context.Background(), &pb.GetUserProfileRequest{UserId: targetUserID})
// 	if err != nil {
// 		c.JSON(http.StatusNotFound, gin.H{"error": "获取用户信息失败: " + err.Error()})
// 		return
// 	}

// 	c.JSON(http.StatusOK, res)
// }

// // deleteUserHandler (正确版本)
// func deleteUserHandler(c *gin.Context) {
// 	// ① 从JWT中间件获取 claims
// 	claimsAny, exists := c.Get("userClaims")
// 	if !exists {
// 		c.JSON(http.StatusUnauthorized, gin.H{"error": "未登录或Token无效"})
// 		return
// 	}
// 	claims, ok := claimsAny.(*models.Claims)
// 	if !ok {
// 		c.JSON(http.StatusInternalServerError, gin.H{"error": "无法解析用户信息"})
// 		return
// 	}

// 	// ② 从URL路径获取目标ID (假设路由为 /api/user/:id)
// 	targetUserIDStr := c.Param("id")
// 	targetUserID, err := strconv.ParseInt(targetUserIDStr, 10, 64)
// 	if err != nil {
// 		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的目标用户ID"})
// 		return
// 	}

// 	// ③【核心修正】进行授权检查
// 	if claims.UserID != targetUserID {
// 		c.JSON(http.StatusForbidden, gin.H{"error": "权限不足，无法删除他人账户"})
// 		return
// 	}

// 	// 调用 gRPC 服务
// 	res, err := userClient.DeleteUser(context.Background(), &pb.DeleteUserRequest{UserId: targetUserID})
// 	if err != nil {
// 		c.JSON(http.StatusInternalServerError, gin.H{"error": "删除用户失败: " + err.Error()})
// 		return
// 	}

// 	c.JSON(http.StatusOK, res)
// }

// // === JWT 中间件 ===

// // jwtMiddleware 验证从客户端发来的 JWT
// func jwtMiddleware() gin.HandlerFunc {
// 	return func(c *gin.Context) {
// 		authHeader := c.GetHeader("Authorization")
// 		if authHeader == "" {
// 			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "请求头缺少 Authorization"})
// 			return
// 		}

// 		parts := strings.Split(authHeader, " ")
// 		if len(parts) != 2 || parts[0] != "Bearer" {
// 			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Authorization 请求头格式错误"})
// 			return
// 		}
// 		tokenString := parts[1]

// 		claims := &models.Claims{}
// 		token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
// 			return config.JWTKey, nil // 使用与 Auth Service 共享的密钥
// 		})

// 		if err != nil || !token.Valid {
// 			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "无效的 Token"})
// 			return
// 		}

// 		// 验证通过，将用户ID存入 Gin 的上下文中，方便后续的 Handler 使用
// 		c.Set("userID", claims.UserID)

// 		// 继续处理请求
// 		c.Next()
// 	}
// }

// func main() {
// 	// --- 1. 连接后端的 gRPC 服务 ---
// 	// 连接 Auth Service
// 	authConn, err := grpc.NewClient("localhost:8081", grpc.WithTransportCredentials(insecure.NewCredentials()))
// 	if err != nil {
// 		log.Fatalf("无法连接 Auth Service: %v", err)
// 	}
// 	defer authConn.Close()
// 	authClient = pb.NewAuthServiceClient(authConn)

// 	// 连接 User Service
// 	userConn, err := grpc.NewClient("localhost:8082", grpc.WithTransportCredentials(insecure.NewCredentials()))
// 	if err != nil {
// 		log.Fatalf("无法连接 User Service: %v", err)
// 	}
// 	defer userConn.Close()
// 	userClient = pb.NewUserServiceClient(userConn)

// 	// --- 2. 设置 Gin 路由器 ---
// 	router := gin.Default()

// 	// 公开路由，用于注册和登录
// 	router.POST("/register", registerHandler)
// 	router.POST("/login", loginHandler)

// 	// 受保护的路由组，所有在此组下的路由都需要经过 JWT 中间件的验证
// 	api := router.Group("/api")
// 	api.Use(jwtMiddleware())
// 	{
// 		api.GET("/profile", profileHandler)
// 		// 未来可以继续在这里添加其他受保护的接口
// 		// 例如:
// 		api.DELETE("/user", deleteUserHandler)
// 	}

// 	// --- 3. 启动 API 网关服务 ---
// 	port := "8080"
// 	fmt.Printf("🚀 API Gateway (Gin <-> gRPC) 启动于 http://localhost:%s\n", port)
// 	if err := router.Run(":" + port); err != nil {
// 		log.Fatalf("网关启动失败: %v", err)
// 	}
// }

// // const (
// // 	authServiceURL = "http://localhost:8081"
// // 	userServiceURL = "http://localhost:8082"
// // )

// // // proxyToService 代理函数，将请求转发给下游服务
// // func proxyToService(serviceURL string) gin.HandlerFunc {
// // 	return func(c *gin.Context) {
// // 		// 1. 复制请求体（如果存在）
// // 		var bodyBytes []byte
// // 		if c.Request.Body != nil {
// // 			bodyBytes, _ = io.ReadAll(c.Request.Body)
// // 		}
// // 		c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // 把读过的 Body 再放回去

// // 		// 2. 创建一个指向下游服务的新请求
// // 		targetURL := serviceURL + c.Request.URL.Path
// // 		proxyReq, err := http.NewRequest(c.Request.Method, targetURL, bytes.NewReader(bodyBytes))
// // 		if err != nil {
// // 			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建代理请求失败"})
// // 			return
// // 		}

// // 		// 3. 复制原始请求的头
// // 		proxyReq.Header = c.Request.Header
// // 		proxyReq.Header.Set("X-Forwarded-For", c.ClientIP())

// // 		// 4. 发送代理请求
// // 		client := &http.Client{}
// // 		resp, err := client.Do(proxyReq)
// // 		if err != nil {
// // 			c.JSON(http.StatusServiceUnavailable, gin.H{"error": "无法连接下游服务"})
// // 			return
// // 		}
// // 		defer resp.Body.Close()

// // 		// 5. 将下游服务的响应写回给原始客户端
// // 		c.Status(resp.StatusCode)
// // 		for key, values := range resp.Header {
// // 			for _, value := range values {
// // 				c.Writer.Header().Add(key, value)
// // 			}
// // 		}
// // 		io.Copy(c.Writer, resp.Body)
// // 	}
// // }

// // // profileProxyHandler 是一个特殊的代理，它需要从JWT中提取ID并重写URL
// // func profileProxyHandler(c *gin.Context) {
// // 	// 从JWT中间件设置的上下文中获取用户ID
// // 	userID := c.MustGet("userID").(int64)

// // 	// 重写URL，例如将 /api/profile 变为 /users/123
// // 	targetURL := fmt.Sprintf("%s/users/%d", userServiceURL, userID)

// // 	proxyReq, err := http.NewRequest("GET", targetURL, nil)
// // 	if err != nil {
// // 		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建代理请求失败"})
// // 		return
// // 	}
// // 	proxyReq.Header = c.Request.Header

// // 	client := &http.Client{}
// // 	resp, err := client.Do(proxyReq)
// // 	if err != nil {
// // 		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "无法连接用户服务"})
// // 		return
// // 	}
// // 	defer resp.Body.Close()

// // 	c.Status(resp.StatusCode)
// // 	for key, values := range resp.Header {
// // 		for _, value := range values {
// // 			c.Writer.Header().Add(key, value)
// // 		}
// // 	}
// // 	io.Copy(c.Writer, resp.Body)
// // }

// // func main() {
// // 	router := gin.Default()

// // 	// 公开路由直接转发给 Auth Service
// // 	router.POST("/register", proxyToService(authServiceURL))
// // 	router.POST("/login", proxyToService(authServiceURL))

// // 	// 受保护的路由组
// // 	api := router.Group("/api")
// // 	api.Use(handlers.JWTMiddleware()) // 使用JWT认证中间件
// // 	{
// // 		// /api/profile 请求由特殊的 handler 处理
// // 		api.GET("/profile", profileProxyHandler)
// // 		// 未来可以添加其他受保护的路由，例如订单服务
// // 		// api.GET("/orders", proxyToService("http://localhost:8083"))
// // 	}

// // 	port := "8080"
// // 	fmt.Printf("🚀 API Gateway (Gin) 启动于 http://localhost:%s\n", port)
// // 	if err := router.Run(":" + port); err != nil {
// // 		log.Fatalf("网关启动失败: %v", err)
// // 	}
// // }

package main

import (
	// "bytes"
	"fmt"
	"io"
	"log"
	"net/http"
	"strconv"

	// 确保这里的 import 路径正确
	// "grpc-jwt-yonghurenzheng/jwt_grpc_gin/config"
	"grpc-jwt-yonghurenzheng/jwt_grpc_gin/handlers"
	// "grpc-jwt-yonghurenzheng/jwt_grpc_gin/models"

	"github.com/gin-gonic/gin"
)

const (
	authServiceURL = "http://localhost:8081"
	userServiceURL = "http://localhost:8082"
)

// proxyToService 代理函数，将公开请求直接转发给下游服务
func proxyToService(serviceURL string, c *gin.Context) {
	targetURL := serviceURL + c.Request.URL.Path
	
	// 创建一个新的HTTP请求，方法和目标URL与原始请求一致
	proxyReq, err := http.NewRequest(c.Request.Method, targetURL, c.Request.Body)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建代理请求失败"})
		return
	}
	
	// 复制原始请求的头
	proxyReq.Header = c.Request.Header
	
	// 发送代理请求
	client := &http.Client{}
	resp, err := client.Do(proxyReq)
	if err != nil {
		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "无法连接下游服务: " + err.Error()})
		return
	}
	defer resp.Body.Close()
	
	// 将下游服务的响应写回给原始客户端
	c.Status(resp.StatusCode)
	for key, values := range resp.Header {
		for _, value := range values {
			c.Writer.Header().Set(key, value)
		}
	}
	io.Copy(c.Writer, resp.Body)
}


func main() {
	router := gin.Default()
	
	// 公开路由直接转发给 Auth Service
	router.POST("/register", func(c *gin.Context) {
		proxyToService(authServiceURL, c)
	})
	router.POST("/login", func(c *gin.Context) {
		proxyToService(authServiceURL, c)
	})
	
	// 受保护的路由组
	api := router.Group("/api")
	// 注意：这里的 middlewares.AuthRequired() 是您之前为Gin写的JWT中间件
	api.Use(handlers.JWTMiddleware()) 
	{
		// /api/profile 请求需要特殊处理，因为URL需要重写
		api.GET("/profile", func(c *gin.Context) {
			// 从JWT中间件设置的上下文中获取用户ID
			userID := c.MustGet("userID").(int64)
			
			// 重写URL，例如将 /api/profile 变为 /users/123
			// 这是调用 User Service 的接口
			c.Request.URL.Path = "/users/" + strconv.FormatInt(userID, 10)
			
			proxyToService(userServiceURL, c)
		})

		// /api/delete_user 请求也需要重写URL
		api.DELETE("/user", func(c *gin.Context) {
			userID := c.MustGet("userID").(int64)
			// User Service 的删除接口是 /delete_users/:id
			c.Request.URL.Path = "/delete_users/" + strconv.FormatInt(userID, 10)
			proxyToService(userServiceURL, c)
		})
	}
	
	port := "8080"
	fmt.Printf("🚀 API Gateway (Gin <-> HTTP) 启动于 http://localhost:%s\n", port)
	if err := router.Run(":" + port); err != nil {
		log.Fatalf("网关启动失败: %v", err)
	}
}